{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LeNet5Like(\n",
      "  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch  \n",
    "import torch.nn as nn  \n",
    "import torch.nn.functional as F \n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "\n",
    "\n",
    "  \n",
    "class LeNet5Like(nn.Module):  \n",
    "    def __init__(self):  \n",
    "        super(LeNet5Like, self).__init__()  \n",
    "        # 第一层：卷积层  \n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1, padding=2)  \n",
    "        # 第二层：池化层  \n",
    "        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)  \n",
    "          \n",
    "        # 第三层：卷积层  \n",
    "        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1)  \n",
    "        # 第四层：池化层  \n",
    "        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)  \n",
    "          \n",
    "        # 第五层：全连接层  \n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 假设输入图片是32x32，经过两次池化后变为5x5  \n",
    "        self.fc2 = nn.Linear(120, 84)  \n",
    "        self.fc3 = nn.Linear(84, 10)  # 假设是10类分类问题  \n",
    "  \n",
    "    def forward(self, x):  \n",
    "        # 第一层卷积和池化  \n",
    "        x = self.pool1(F.relu(self.conv1(x)))  \n",
    "          \n",
    "        # 第二层卷积和池化  \n",
    "        x = self.pool2(F.relu(self.conv2(x)))  \n",
    "          \n",
    "        # 展平，准备进入全连接层  \n",
    "        x = torch.flatten(x, 1)  # 将多维的输入一维化  \n",
    "          \n",
    "        # 全连接层  \n",
    "        x = F.relu(self.fc1(x))  \n",
    "        x = F.relu(self.fc2(x))  \n",
    "        x = self.fc3(x)  \n",
    "          \n",
    "        return x  \n",
    "  \n",
    "# 实例化网络  \n",
    "net = LeNet5Like()  \n",
    "print(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#定义图像读入的辅助函数\n",
    "import cv2\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def find_files_recursive(root_dir, extensions, max_level=float('inf')):  \n",
    "    \"\"\"  \n",
    "    递归查找指定目录下的文件，直到达到指定的最大层级或找到所有匹配的文件。  \n",
    "  \n",
    "    :param root_dir: 根目录  \n",
    "    :param extensions: 一个包含文件扩展名的列表，如 ['.txt', '.csv', '.nii']  \n",
    "    :param max_level: 最大搜索层级，默认为无穷大  \n",
    "    :return: 所有找到的文件列表  \n",
    "    \"\"\"  \n",
    "    found_files = []  \n",
    "  \n",
    "    def search_files(path, current_level):  \n",
    "        nonlocal found_files  \n",
    "        for item in os.listdir(path):  \n",
    "            item_path = os.path.join(path, item)  \n",
    "            # 如果是文件且扩展名在列表中，则添加到列表中  \n",
    "            if os.path.isfile(item_path) and os.path.splitext(item_path)[1].lower() in extensions:  \n",
    "                found_files.append(item_path)  \n",
    "            # 如果是目录且未达到最大层级，则递归搜索  \n",
    "            elif os.path.isdir(item_path) and current_level < max_level:  \n",
    "                search_files(item_path, current_level + 1)  \n",
    "  \n",
    "    search_files(root_dir, 0)  \n",
    "    return found_files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "每种图像的数量是{0: 11, 1: 6, 2: 56, 3: 62}\n",
      "图像的大小是(120,188)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#读取图像\n",
    "# 创建一个空列表来存储包含PSG矩阵和标签的字典 \n",
    "patient_data_list = [] \n",
    "\n",
    "root_directory = r\"C:\\Users\\86180\\Desktop\\CNN\\data\"\n",
    "extensions = ['.png']  # 扩展名列表，可以写多个进去  \n",
    "files = find_files_recursive(root_directory, extensions)\n",
    "\n",
    "#计数\n",
    "label_counts = {} \n",
    "\n",
    "for file in files :\n",
    "    # 使用os.path.dirname获取文件所在的目录  \n",
    "    directory = os.path.dirname(file)      \n",
    "    # 再次使用os.path.basename获取目录名（即最后一个文件夹的名称）  \n",
    "    folder_name = os.path.basename(directory) \n",
    "\n",
    "    label = int(folder_name) \n",
    "\n",
    "    # 更新标签计数  \n",
    "    if label in label_counts:  \n",
    "        label_counts[label] += 1  \n",
    "    else:  \n",
    "        label_counts[label] = 1\n",
    "     \n",
    "\n",
    "    im = cv2.imread(file , 0)\n",
    "    row, col = im.shape  # 得到图像尺寸\n",
    "\n",
    "\n",
    "    # 将PSG矩阵和标签组合成一个字典  \n",
    "    patient_data = {  \n",
    "    'psg_matrix':im,  \n",
    "    'depression_label': label \n",
    "    }  \n",
    "    # 将字典添加到列表中  \n",
    "    patient_data_list.append(patient_data)\n",
    "\n",
    "print(f\"每种图像的数量是{label_counts}\")\n",
    "print(f\"图像的大小是({row},{col})\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset length: 135\n",
      "Epoch [1/10], Loss: 512.7250\n",
      "Epoch [2/10], Loss: 86.8384\n",
      "Epoch [3/10], Loss: 30.3739\n",
      "Epoch [4/10], Loss: 17.6992\n",
      "Epoch [5/10], Loss: 8.1013\n",
      "Epoch [6/10], Loss: 1.7818\n",
      "Epoch [7/10], Loss: 1.8396\n",
      "Epoch [8/10], Loss: 0.9648\n",
      "Epoch [9/10], Loss: 0.2810\n",
      "Epoch [10/10], Loss: 0.2537\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "# 创建数据集和数据加载器\n",
    "\n",
    "batch_size=16    #很难再高了\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "# 自定义 collate_fn  \n",
    "def custom_collate_fn(batch):  \n",
    "    psg_matrices = [item[0] for item in batch]  \n",
    "    labels = torch.stack([item[1] for item in batch])  \n",
    "    # 假设所有 psg_matrices 的形状相同（除了批次维度）  \n",
    "    # 如果不是，您可能需要进一步处理这些矩阵  \n",
    "    psg_matrices_tensor = torch.stack(psg_matrices, dim=0)  \n",
    "    return psg_matrices_tensor, labels\n",
    "\n",
    "class PSGDataset(Dataset):\n",
    "    def __init__(self, patient_data_list):\n",
    "        self.patient_data_list = patient_data_list\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.patient_data_list)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        patient_data = self.patient_data_list[idx]\n",
    "        psg_matrix = torch.tensor(patient_data['psg_matrix'], dtype=torch.float32)\n",
    "        label = torch.tensor(patient_data['depression_label'], dtype=torch.long)\n",
    "        return psg_matrix, label\n",
    "\n",
    "dataset = PSGDataset(patient_data_list)\n",
    "\n",
    "print(f'Dataset length: {len(dataset)}')\n",
    "\n",
    "data_loader = DataLoader(dataset, batch_size = batch_size, shuffle=True, collate_fn=custom_collate_fn,pin_memory=True,num_workers=0)  #期望的输入是四维张量（[batch_size, channels, height, width]）\n",
    "\n",
    "import torch.nn as nn\n",
    "\n",
    "\n",
    "class ConvNet(nn.Module):  \n",
    "    def __init__(self, num_input_channels, num_classes):  # 假设输入是灰度图像，输出类别数为10  \n",
    "        super(ConvNet, self).__init__()  \n",
    "        # 第一个卷积层，输入通道数为1（灰度图），输出通道数为16，卷积核大小为3x3  \n",
    "\n",
    "        self.conv1 = nn.Conv2d(num_input_channels, 16, kernel_size=3, stride=1, padding=1)  \n",
    "        # 第二个卷积层，输入通道数为第一个卷积层的输出通道数（16），输出通道数为32  \n",
    "        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)  \n",
    "\n",
    "        # 在全连接层之前，需要确定输入特征图的尺寸，以便正确地展平。这里假设经过两次池化后，尺寸变为原始尺寸的1/4  \n",
    "        # 假设原始图像大小为(N, 1, 120, 188)，则池化后大约为(N, 32, 30, 47)。但这只是估算，实际中可能因padding等有所不同。  \n",
    "        # 假设最终特征图尺寸为(N, 32, 15, 24)（仅作示例，实际应根据具体情况计算） \n",
    "        # \n",
    "        # # 计算全连接层前的特征图尺寸（假设输入图像尺寸为(N, 1, 120, 188)）  \n",
    "        # 经过两次3x3卷积（padding=1）和两次2x2最大池化（stride=2）后  \n",
    "        # 特征图尺寸变为(N, 32, 30, 47) \n",
    "#After conv1: torch.Size([16, 16, 120, 188])\n",
    "# After pool: torch.Size([16, 16, 60, 94])\n",
    "# After conv2: torch.Size([16, 32, 60, 94])\n",
    "# After second pool: torch.Size([16, 32, 30, 47])\n",
    "# Flattened shape: torch.Size([16, 45120])\n",
    "        \n",
    "\n",
    "        self.fc1 = nn.Linear(32 * 30 * 47, 120)  # 全连接层1，输入特征数为32 * 30 * 47，输出特征数为120  \n",
    "        self.fc2 = nn.Linear(120, num_classes)  # 全连接层2，输入特征数为120，输出特征数为类别数  \n",
    "  \n",
    "    def forward(self, x):  \n",
    "        # 保留批次大小以便后续处理  \n",
    "        batch_size = x.size(0) \n",
    "\n",
    "  #      print(\"Input shape:\", x.shape) \n",
    "  \n",
    "        # 卷积层1 + ReLU激活  \n",
    "        out = self.conv1(x)\n",
    " #       print(\"After conv1:\", out.shape)  \n",
    "        out = F.relu(out)  \n",
    "  \n",
    "        # 2x2最大池化，步长为2  \n",
    "        out = F.max_pool2d(out, 2, 2)  \n",
    "\n",
    " #       print(\"After pool:\", out.shape)\n",
    "  \n",
    "        # 卷积层2 + ReLU激活  \n",
    "        out = self.conv2(out) \n",
    " #       print(\"After conv2:\", out.shape)\n",
    "\n",
    "        out = F.relu(out)  \n",
    "  \n",
    "        # 再次池化  \n",
    "        out = F.max_pool2d(out, 2, 2) \n",
    " #       print(\"After second pool:\", out.shape) \n",
    "  \n",
    "        # 将特征图展平为一维向量  \n",
    "        out = out.view(batch_size, -1)  \n",
    "\n",
    " #       print(\"Flattened shape:\", out.shape)\n",
    "  \n",
    "        # 全连接层1 + ReLU激活  \n",
    "        out = self.fc1(out) \n",
    "\n",
    " #       print(\"fc1 shape:\", out.shape) \n",
    "        out = F.relu(out)  \n",
    "  \n",
    "        # 全连接层2 + log_softmax激活（通常用于多分类问题的损失计算）  \n",
    "        out = self.fc2(out) \n",
    "\n",
    "        out = F.log_softmax(out, dim=1)  \n",
    "  \n",
    "        return out \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\86180\\miniconda3\\envs\\python_3.8\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "c:\\Users\\86180\\miniconda3\\envs\\python_3.8\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "c:\\Users\\86180\\miniconda3\\envs\\python_3.8\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1471: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1       0.00      0.00      0.00         1\n",
      "           2       0.86      0.86      0.86         7\n",
      "           3       0.86      1.00      0.92         6\n",
      "\n",
      "    accuracy                           0.86        14\n",
      "   macro avg       0.57      0.62      0.59        14\n",
      "weighted avg       0.80      0.86      0.82        14\n",
      "\n",
      "Fold 1, Validation Loss: 0.7198\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         2\n",
      "           1       1.00      1.00      1.00         2\n",
      "           2       1.00      1.00      1.00         5\n",
      "           3       1.00      1.00      1.00         5\n",
      "\n",
      "    accuracy                           1.00        14\n",
      "   macro avg       1.00      1.00      1.00        14\n",
      "weighted avg       1.00      1.00      1.00        14\n",
      "\n",
      "Fold 2, Validation Loss: 0.0024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         1\n",
      "           1       1.00      1.00      1.00         1\n",
      "           2       1.00      1.00      1.00         5\n",
      "           3       1.00      1.00      1.00         7\n",
      "\n",
      "    accuracy                           1.00        14\n",
      "   macro avg       1.00      1.00      1.00        14\n",
      "weighted avg       1.00      1.00      1.00        14\n",
      "\n",
      "Fold 3, Validation Loss: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         1\n",
      "           2       1.00      1.00      1.00         9\n",
      "           3       1.00      1.00      1.00         4\n",
      "\n",
      "    accuracy                           1.00        14\n",
      "   macro avg       1.00      1.00      1.00        14\n",
      "weighted avg       1.00      1.00      1.00        14\n",
      "\n",
      "Fold 4, Validation Loss: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         2\n",
      "           2       1.00      1.00      1.00         7\n",
      "           3       1.00      1.00      1.00         5\n",
      "\n",
      "    accuracy                           1.00        14\n",
      "   macro avg       1.00      1.00      1.00        14\n",
      "weighted avg       1.00      1.00      1.00        14\n",
      "\n",
      "Fold 5, Validation Loss: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         2\n",
      "           1       1.00      1.00      1.00         1\n",
      "           2       1.00      1.00      1.00         5\n",
      "           3       1.00      1.00      1.00         5\n",
      "\n",
      "    accuracy                           1.00        13\n",
      "   macro avg       1.00      1.00      1.00        13\n",
      "weighted avg       1.00      1.00      1.00        13\n",
      "\n",
      "Fold 6, Validation Loss: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         1\n",
      "           2       1.00      1.00      1.00         4\n",
      "           3       1.00      1.00      1.00         8\n",
      "\n",
      "    accuracy                           1.00        13\n",
      "   macro avg       1.00      1.00      1.00        13\n",
      "weighted avg       1.00      1.00      1.00        13\n",
      "\n",
      "Fold 7, Validation Loss: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           2       1.00      1.00      1.00         7\n",
      "           3       1.00      1.00      1.00         6\n",
      "\n",
      "    accuracy                           1.00        13\n",
      "   macro avg       1.00      1.00      1.00        13\n",
      "weighted avg       1.00      1.00      1.00        13\n",
      "\n",
      "Fold 8, Validation Loss: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         2\n",
      "           2       1.00      1.00      1.00         5\n",
      "           3       1.00      1.00      1.00         6\n",
      "\n",
      "    accuracy                           1.00        13\n",
      "   macro avg       1.00      1.00      1.00        13\n",
      "weighted avg       1.00      1.00      1.00        13\n",
      "\n",
      "Fold 9, Validation Loss: 0.0000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1       1.00      1.00      1.00         1\n",
      "           2       1.00      1.00      1.00         2\n",
      "           3       1.00      1.00      1.00        10\n",
      "\n",
      "    accuracy                           1.00        13\n",
      "   macro avg       1.00      1.00      1.00        13\n",
      "weighted avg       1.00      1.00      1.00        13\n",
      "\n",
      "Fold 10, Validation Loss: 0.0000\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#训练模型\n",
    "from sklearn.model_selection import KFold\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "from sklearn.metrics import confusion_matrix, classification_report  \n",
    "import matplotlib.pyplot as plt  \n",
    "import seaborn as sns \n",
    "\n",
    "input_size = 26  # 特征维度，这是输入数据决定的\n",
    "hidden_size = 64  #可以调整的参数，通过交叉验证决定\n",
    "\n",
    "\n",
    "\n",
    "num_epochs = 10     #实际的轮数依赖于数据集的大小和训练进展。\n",
    "learning_rate = 0.001   #也可以做文章\n",
    "\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = ConvNet( num_input_channels = 1, num_classes = 4).to(device)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "accumulation_steps = 4      # 累积梯度的步骤数\n",
    "\n",
    "\n",
    "# 使用 KFold 进行十折交叉验证  \n",
    "kf = KFold(n_splits=10, shuffle=True, random_state=42) \n",
    "\n",
    "for fold, (train_indices, val_indices) in enumerate(kf.split(dataset)):  \n",
    "    # 划分训练集和验证集  \n",
    "    train_sampler = torch.utils.data.SubsetRandomSampler(train_indices)  \n",
    "    val_sampler = torch.utils.data.SubsetRandomSampler(val_indices)  \n",
    "  \n",
    "    train_loader = DataLoader(dataset, batch_size=batch_size, sampler=train_sampler, collate_fn=custom_collate_fn)  \n",
    "    val_loader = DataLoader(dataset, batch_size=batch_size, sampler=val_sampler, collate_fn=custom_collate_fn)  \n",
    "  \n",
    "    # 训练模型  \n",
    "    model.train() \n",
    "    for epoch in range(num_epochs):  \n",
    "        optimizer.zero_grad()  # 清除之前的梯度  \n",
    "        torch.cuda.empty_cache()  # 清除 GPU 缓存  \n",
    "        for i, (psg_matrices, labels) in enumerate(data_loader):\n",
    "\n",
    "            psg_matrices, labels = psg_matrices.to(device), labels.to(device) \n",
    "\n",
    "            # 打印数据的形状  \n",
    "    #      print(f\"Input shape for batch {i}: {psg_matrices.shape}\") \n",
    "\n",
    "            psg_matrices = psg_matrices.unsqueeze(1)  # 这会在第1维（索引为1的维度）上增加一个大小为1的维度\n",
    "\n",
    "    #       print(f\"Input shape for batch {i}: {psg_matrices.shape}\") \n",
    "\n",
    "            outputs = model(psg_matrices)  \n",
    "            loss = criterion(outputs, labels)  \n",
    "            loss.backward()  \n",
    "    \n",
    "            if (i + 1) % accumulation_steps == 0:  \n",
    "                optimizer.step()  \n",
    "                optimizer.zero_grad()  # 重置梯度\n",
    "\n",
    "    # 验证模型\n",
    "    # # 用于存储预测和真实标签 \n",
    "    #  \n",
    "    predictions = []  \n",
    "    labels = []  \n",
    "\n",
    "    model.eval()  \n",
    "    val_loss = 0.0  \n",
    "    with torch.no_grad():  \n",
    "        for psg_matrices, val_labels in val_loader:  \n",
    "            psg_matrices, val_labels = psg_matrices.to(device), val_labels.to(device)  \n",
    "            psg_matrices = psg_matrices.unsqueeze(1)  \n",
    "            \n",
    "            outputs = model(psg_matrices)  \n",
    "            loss = criterion(outputs, val_labels)  \n",
    "            val_loss += loss.item() \n",
    "\n",
    "                    # 获取预测结果（假设是分类任务，使用argmax获取类别索引）  \n",
    "            _, predicted = torch.max(outputs.data, 1)  \n",
    "          \n",
    "             # 将预测结果和真实标签添加到列表中  \n",
    "            predictions.extend(predicted.cpu().numpy())  \n",
    "            labels.extend(val_labels.cpu().numpy())  \n",
    "    \n",
    "    # 计算混淆矩阵  \n",
    "    cm = confusion_matrix(labels, predictions)  \n",
    "    \n",
    "    # 可视化混淆矩阵  \n",
    "    sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\")  \n",
    "    plt.ylabel('True label')  \n",
    "    plt.xlabel('Predicted label')  \n",
    "    plt.title('Confusion Matrix')  \n",
    "    plt.show()  \n",
    "    \n",
    "    # 如果你还需要其他性能指标，可以使用classification_report等函数  \n",
    "    report = classification_report(labels, predictions)  \n",
    "    print(report)        \n",
    "  \n",
    "    val_loss /= len(val_loader)\n",
    "  \n",
    "    print(f'Fold {fold+1}, Validation Loss: {val_loss:.4f}')\n",
    "\n",
    "\n",
    "\n",
    "            \n",
    "\n",
    "\n",
    "\n",
    "print('Finished Training')\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python_3.8",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
